﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Sinacor.Infra.UI.Common;
using Sinacor.Infra.Common.Exceptions;
using Sinacor.Infra.Common.Validation;
using Sinacor.UI.Bovespa.Ordens;
using PSE.Framework.UI.Resources;
using System.IO;

namespace Sinacor.UI.Bovespa.Ordens.Presenter
{
    public class ManutencaoOrdemPresenter : Sinacor.Infra.UI.Common.BasePresenter<IManutencaoOrdem>
    {
        #region Construtor
        public ManutencaoOrdemPresenter(IManutencaoOrdem view) : base(view){
             Ordem = new Sinacor.UI.Bovespa.Ordens.Model.Ordem();
        }
        #endregion Construtor

        #region Atributo
        private ModelCollection<Model.Operador> _ListOperador;
        private ModelCollection<Model.Calendario> _ListCalendario;
        private ModelCollection<Model.Ordem> _ListOrdem;
        private string _ResourceKey;
        private bool _DigitoClienteVerificador;
        private Model.Parameter.ConsultarOrdem _ConsultarOrdem = new Sinacor.UI.Bovespa.Ordens.Model.Parameter.ConsultarOrdem();
        private bool _PermissaoIncluir;
        private bool _PermissaoAlterar;
        private bool _PermissaoCancelar;
        private bool _PermissaoAlterarPercentualAcrescimo;
        private bool _PermissaoAlterarAtivoOrdem;
        private bool _PermissaoAlterarQuantidadeOrdem;
        private ModelCollection<Model.Justificativa> _ListJustificativa;
        private ModelCollection<Model.Justificativa> _ListJustificativaPadrao;
        private Model.Justificativa _Justificativa = new Sinacor.UI.Bovespa.Ordens.Model.Justificativa();
        private Model.Observacao _Observacao = new Sinacor.UI.Bovespa.Ordens.Model.Observacao();
        private List<string> _ErroValidacao = new List<string>();
        private List<string> _MensagemValidacao = new List<string>();
        private ModelCollection<Model.Ordem> _ListFinanciamentoPOP;
        private Model.Ordem _FinanciamentoPOPCompra;
        private Model.Ordem _FinanciamentoPOPVenda;
		private DateTime _DataPregao;
		private Model.Cliente _Cliente = new Sinacor.UI.Bovespa.Ordens.Model.Cliente();
		private ModelCollection<Model.EmissorOrdem> _ListEmissorOrdem;
		private Model.Titulo _Titulo;
		private List<string> _ListError = new List<string>();
		private Model.Operador _Operador;
		private Model.Calendario _Calendario;
        #endregion Atributo

        #region Propriedade
        /// <summary>
        /// Lista de Operadores
        /// </summary>
        public ModelCollection<Model.Operador> ListOperador{
            get{
                return _ListOperador;
            }private set{
                _ListOperador = value;
                if( ListOperador != null) {
                    ListOperador.EnableStateControl = true;
                }
            }
        }

        /// <summary>
        /// Lista de datas validas para filtro do pregao
        /// </summary>
        public ModelCollection<Model.Calendario> ListCalendario{
            get{
                return _ListCalendario;
            }private set{
                _ListCalendario = value;
                if( ListCalendario != null) {
                    ListCalendario.EnableStateControl = true;
                }
            }
        }

        /// <summary>
        /// Lista de ordens
        /// </summary>
        public ModelCollection<Model.Ordem> ListOrdem{
            get{
                return _ListOrdem;
            }private set{
                _ListOrdem = value;
                if( ListOrdem != null) {
                    ListOrdem.EnableStateControl = true;
                }
            }
        }

        /// <summary>
        /// Ordem Selecionada
        /// </summary>
        public Model.Ordem Ordem{
            get;
            set;
        }
        
        /// <summary>
        /// RecourceKey para mensagens de erro/aviso
        /// </summary>
        public string ResourceKey{
            get{
                return _ResourceKey;
            }private set{
                _ResourceKey = value;
            }
        }
        
        /// <summary>
        /// Indicado se o DigitoClienteVerificador é necessário
        /// </summary>
        public bool DigitoClienteVerificador{
            get {
                return _DigitoClienteVerificador;
            }set{
                _DigitoClienteVerificador = value;
            }
        }
        
        /// <summary>
        /// Campos de Consulta da ordem
        /// </summary>
        public Model.Parameter.ConsultarOrdem ConsultarOrdem{
            get{
                return _ConsultarOrdem;
            }set{
                _ConsultarOrdem = value;
            }
        }
        
        /// <summary>
        /// Permissão para incluir ordem
        /// </summary>
        public bool PermissaoIncluir{
            get{
                return _PermissaoIncluir;
            }set{
                _PermissaoIncluir = value;
            }
        }

        /// <summary>
        /// Permissão para alterar ordem
        /// </summary>
        public bool PermissaoAlterar{
            get{
                return _PermissaoAlterar;
            }set{
                _PermissaoAlterar = value;
            }
        }

        /// <summary>
        /// Permissão para cancelar ordem
        /// </summary>
        public bool PermissaoCancelar{
            get{
                return _PermissaoCancelar;
            }set{
                _PermissaoCancelar = value;
            }
        }

        /// <summary>
        /// Permissão para alterar o campo Percentual Acrescimo
        /// </summary>
        public bool PermissaoAlterarPercentualAcrescimo{
            get{
                return _PermissaoAlterarPercentualAcrescimo;
            }set{
                _PermissaoAlterarPercentualAcrescimo = value;
            }
        }
        
        /// <summary>
        /// Permissão para alterar o Ativo(Titulo) da ordem
        /// </summary>
        public bool PermissaoAlterarAtivoOrdem{
            get{
                return _PermissaoAlterarAtivoOrdem;
            }set{
                _PermissaoAlterarAtivoOrdem = value;
            }
        }
        
        /// <summary>
        /// Permissão para alterar quantidade
        /// </summary>
        public bool PermissaoAlterarQuantidadeOrdem{
            get{
                return _PermissaoAlterarQuantidadeOrdem;
            }set{
                _PermissaoAlterarQuantidadeOrdem = value;
            }
        }

        /// <summary>
        /// Lista de Justificativas de uma ordem
        /// </summary>
        public ModelCollection<Model.Justificativa> ListJustificativa
        {
            get{
                return _ListJustificativa;
            }set{
                _ListJustificativa = value;
            }
        }

        /// <summary>
        /// Lista de Justificativas Padrao
        /// </summary>
        public ModelCollection<Model.Justificativa> ListJustificativaPadrao{
            get{
                return _ListJustificativaPadrao;
            }set{
                _ListJustificativaPadrao = value;
            }
        }

        /// <summary>
        /// Justificativa que será salva
        /// </summary>
        public Model.Justificativa Justificativa{
            get{
                return _Justificativa;
            }set{
                _Justificativa = value;
            }
        }

        /// <summary>
        /// Observacao da ordem
        /// </summary>
        public Model.Observacao Observacao{
            get{
                return _Observacao;
            }set{
                _Observacao = value;
            }
        }

        /// <summary>
        /// Lista de Erros de validação que deve ser mostrada antes de salvar uma ordem via ShowErro
        /// </summary>
        public List<string> ErroValidacao{
            get{
                return _ErroValidacao;
            }set{
                _ErroValidacao = value;
            }
        }

        /// <summary>
        /// Lista de Mensagens que deve ser mostrada antes de salvar uma ordem via MessageBox
        /// </summary>
        public List<string> MensagemValidacao{
            get{
                return _MensagemValidacao;
            }set{
                _MensagemValidacao = value;
            }
        }

        /// <summary>
        /// Lista de Ordens que são Financiamentos POP
        /// </summary>
        public ModelCollection<Model.Ordem> ListFinanciamentoPOP{
            get{
                return _ListFinanciamentoPOP;
            }set{
                _ListFinanciamentoPOP = value;
            }
        }

        /// <summary>
        /// Ordem do Tipo FinanciamentoPOP
        /// </summary>
        public Model.Ordem FinanciamentoPOPCompra{
            get{
                return _FinanciamentoPOPCompra;
            }set{
                _FinanciamentoPOPCompra = value;
            }
        }

        /// <summary>
        /// Ordem do Tipo FinanciamentoPOP
        /// </summary>
        public Model.Ordem FinanciamentoPOPVenda{
            get{
                return _FinanciamentoPOPVenda;
            }set{
                _FinanciamentoPOPVenda = value;
            }
        }
        
        /// <summary>
        /// Data do Pregão selecionada
        /// </summary>
        public DateTime DataPregao
		{
			get { return _DataPregao; }
			set { _DataPregao = value; }
		}
		
		/// <summary>
		/// Enums do Tipo NaturezaOperação
		/// </summary>
		public System.Collections.ObjectModel.ObservableCollection<EnumWrapper<Model.Enum.TipoNaturezaOperacao>> Enums = EnumWrapper<Model.Enum.TipoNaturezaOperacao>.GetEnums();
		
		/// <summary>
		/// Model de Cliente para a ordem selecionada/ ou ativa.
		/// </summary>
		public Model.Cliente Cliente{
			get{
				return _Cliente;
			}set{
				_Cliente = value;
			}
		}

		/// <summary>
		/// Lista de Emissores referentes a um cliente
		/// </summary>
		public ModelCollection<Model.EmissorOrdem> ListEmissorOrdem{
			get{
				return _ListEmissorOrdem;
			}set{
				_ListEmissorOrdem = value;
			}
		}

		/// <summary>
		/// Titulo da Ordem
		/// </summary>
		public Model.Titulo Titulo{
			get{
				return _Titulo;
			}set{
				_Titulo = value;
			}
		}

		/// <summary>
		/// Lista de Erros de Validação Ativos
		/// </summary>
		public List<string> ListError{
			get{
				return _ListError;
			}set{
				_ListError = value;
			}
		}

		/// <summary>
		/// Operador Logado
		/// </summary>
		public Model.Operador Operador{
			get{
				return _Operador;
			}set{
				_Operador = value;
			}
		}

		/// <summary>
		/// Calendario Selecionado
		/// </summary>
		public Model.Calendario Calendario{
			get{
				return _Calendario;
			}set{
				_Calendario = value;
			}
		}
        #endregion Propriedade

        #region Metodo
        /// <summary>
        /// Realiza as validações de usuário
        /// </summary>
        public void ValidarPermissao(){
            Communication.Acesso objCommunicationAcesso = new Sinacor.UI.Bovespa.Ordens.Communication.Acesso(this.Session);
            Model.Parameter.VeririfcarAcessoFuncao objVerificarAcesso = new Sinacor.UI.Bovespa.Ordens.Model.Parameter.VeririfcarAcessoFuncao();
            Communication.Operador objOperador = new Sinacor.UI.Bovespa.Ordens.Communication.Operador(this.Session);
            ModelCollection<Model.Operador> objListOperador;

            try{
                //verifica permissão de cancelamento, inclusão e alteraração de ordem
                objVerificarAcesso.Funcao = "IORD";
                PermissaoIncluir = objCommunicationAcesso.ValidarAcessoFuncao(objVerificarAcesso);
                objVerificarAcesso.Funcao = "AORD";
                PermissaoAlterar = objCommunicationAcesso.ValidarAcessoFuncao(objVerificarAcesso);
                objVerificarAcesso.Funcao = "EORD";
                PermissaoCancelar = objCommunicationAcesso.ValidarAcessoFuncao(objVerificarAcesso);

                objVerificarAcesso.Funcao = "ARED";
                PermissaoAlterarPercentualAcrescimo = objCommunicationAcesso.ValidarAcessoFuncao(objVerificarAcesso);

                objVerificarAcesso.Funcao = "APAP";
                PermissaoAlterarAtivoOrdem = objCommunicationAcesso.ValidarAcessoFuncao(objVerificarAcesso);

                objVerificarAcesso.Funcao = "AQTD";
                PermissaoAlterarQuantidadeOrdem = objCommunicationAcesso.ValidarAcessoFuncao(objVerificarAcesso);
                //View.ApresentarMenuContextoGridOrdem();

                //verifica se o usuário é um operador
                objListOperador = objOperador.ConsultarOperador();
                if(objListOperador.Count < 1){
                    ResourceKey = "Bovespa.Ordens.Message.UsuarioNaoOperador";
                    View.ApresentarUsuarioSemPermissao();
                }else{
					Operador = objListOperador[0];
                }
            }catch(Exception ex){
                HandleException(ex);
            }
        }

        /// <summary>
        /// Carrega os operadores
        /// </summary>
        public void CarregarOperador(){
            Communication.Operador objCommOperador = new Sinacor.UI.Bovespa.Ordens.Communication.Operador(this.Session);
            
            ListOperador = objCommOperador.ConsultarOperador();

            View.ApresentarOperador();
        }

        /// <summary>
        /// Carrega o calendario
        /// </summary>
        public void CarregarCalendario(){
            Communication.Calendario objCommCalendario = new Sinacor.UI.Bovespa.Ordens.Communication.Calendario(this.Session);
            
            ListCalendario = objCommCalendario.ConsultarCalendario();

            View.ApresentarCalendario();
        }

        /// <summary>
        /// Realiza o filtro do grid de ordens
        /// </summary>
        /// <param name="pConsultarOrdem"></param>
        public void CarregarOrdem(Model.Parameter.ConsultarOrdem pConsultarOrdem){
            Communication.Ordem objCommOrdem = new Sinacor.UI.Bovespa.Ordens.Communication.Ordem(this.Session);

            ListOrdem = objCommOrdem.ConsultarOrdem(pConsultarOrdem);

            View.ApresentarOrdem();

            //Verifica se a tela de Manutenção de ordens foi chamada de outra janela e popula os campos de filtro
            if(pConsultarOrdem.NumeroOrdem != null && pConsultarOrdem.NumeroOrdem != 0 && (ConsultarOrdem.NumeroOrdem == null || ConsultarOrdem.NumeroOrdem == 0)){
                ConsultarOrdem.NumeroOrdem = pConsultarOrdem.NumeroOrdem;
                ConsultarOrdem.DataPregao = pConsultarOrdem.DataPregao;
                View.ApresentarCampoPesquisaOrdem();
            }
        }

        /// <summary>
        /// Compara os itens selecionados e seta os campos do ExpanderOrdem de todos os itens que forem iguais
        /// </summary>
        /// <param name="pListOrdem"></param>
        public void CarregarExpanderOrdem(ModelCollection<Model.Ordem> pListOrdem){
            DateTime? DataOrdem;
            DateTime? Validade;
            int? NumeroOrdem;
            int? NumeroOrdemSubSequencia;
            int? NumeroOrdemOriginal;
            string Situacao, Emissor, Operador;
            System.Decimal? ValorFinanciado;
            decimal? PercentualFinanciado;
            List<EnumWrapper<Model.Enum.TipoOrdem>> TipoOrdem;
            bool flagExisteTipoOrdem = false;
            
            if(pListOrdem.Count < 1){
                return;
            }
            
            DataOrdem = pListOrdem[0].DataOrdem;
            Validade = pListOrdem[0].DataValidade;
            NumeroOrdem = pListOrdem[0].NumeroOrdem;
            NumeroOrdemSubSequencia = pListOrdem[0].NumeroOrdemSequencia;
            Situacao = pListOrdem[0].Situacao;
            NumeroOrdemOriginal = pListOrdem[0].NumeroOrdemOriginal;
            Emissor = pListOrdem[0].NomeEmissorOrdem;
            Operador = pListOrdem[0].LoginOperador;
            ValorFinanciado = pListOrdem[0].ValorFinanciado;
            PercentualFinanciado = pListOrdem[0].PercentualFinanciado;
            TipoOrdem = pListOrdem[0].TipoOrdem;

            for(int i=0; i<pListOrdem.Count; i++){
                
                if(DataOrdem != pListOrdem[i].DataOrdem){
                    DataOrdem = DateTime.MinValue;
                }
                
                if(Validade != pListOrdem[i].DataValidade){
                    Validade = DateTime.MinValue;
                }
                
                if(NumeroOrdem != pListOrdem[i].NumeroOrdem){
                    NumeroOrdem = -1;
                }
                
                if(NumeroOrdemSubSequencia != pListOrdem[i].NumeroOrdemSequencia){
                    NumeroOrdemSubSequencia = -1;
                }
                
                if(Situacao != pListOrdem[i].Situacao){
                    Situacao = string.Empty;
                }
                
                if(NumeroOrdemOriginal != pListOrdem[i].NumeroOrdemOriginal){
                    NumeroOrdemOriginal = -1;
                }
                
                if(Emissor != pListOrdem[i].NomeEmissorOrdem){
                    Emissor = string.Empty;
                }
                
                if(Operador != pListOrdem[i].LoginOperador){
                    Operador = string.Empty;
                }
                
                if(ValorFinanciado != pListOrdem[i].ValorFinanciado){
                    ValorFinanciado = -1;
                }
                
                if(PercentualFinanciado != pListOrdem[i].PercentualFinanciado){
                    PercentualFinanciado = -1;
                }
                
                
                for(int x=0; x<TipoOrdem.Count; x++){
                    for(int c=0; c<pListOrdem[i].TipoOrdem.Count; c++){
                        if(TipoOrdem[x].Equals(pListOrdem[i].TipoOrdem[c])){
                            flagExisteTipoOrdem = true;
                            break;
                        }
                    }
                    if(!flagExisteTipoOrdem){
                        TipoOrdem.RemoveAt(x);
                    }
                    flagExisteTipoOrdem = false;
                }
            }
            
            Ordem = new Sinacor.UI.Bovespa.Ordens.Model.Ordem();

            if(DataOrdem != DateTime.MinValue){
                Ordem.DataOrdem = Convert.ToDateTime(DataOrdem);
            }
            
            if(Validade != DateTime.MinValue){
                Ordem.DataValidade = Validade;
            }
            if(NumeroOrdem != -1){
                Ordem.NumeroOrdem = NumeroOrdem;
            }
            if(NumeroOrdemSubSequencia != -1){
                Ordem.NumeroOrdemSequencia = Convert.ToInt32(NumeroOrdemSubSequencia);
            }
            Ordem.Situacao = Situacao;
            
            if(NumeroOrdemOriginal != -1){
                Ordem.NumeroOrdemOriginal = NumeroOrdemOriginal;
            }
            
            Ordem.NomeEmissorOrdem = Emissor;
            Ordem.LoginOperador = Operador;
            
            if(ValorFinanciado != -1){
                Ordem.ValorFinanciado = ValorFinanciado;
            }
            
            if(PercentualFinanciado != -1){
                Ordem.PercentualFinanciado = PercentualFinanciado;
            }
            
            Ordem.TipoOrdem = TipoOrdem;

            View.ApresentarExpanderOrdem();
        }

        /// <summary>
        /// Popula Expander de Cliente de acordo com a(s) linha(s) selecionada(s)
        /// </summary>
        /// <param name="pListOrdem"></param>
        public void CarregarExpanderCliente(ModelCollection<Model.Ordem> pListOrdem){
            string ApelidoCliente;
            decimal? PercentualAcrescimoReducao;
            string IndicadorLiquidacao;
            
            if(pListOrdem.Count < 1){
                return;
            }
            
            ApelidoCliente = pListOrdem[0].ApelidoCliente;
            PercentualAcrescimoReducao = pListOrdem[0].PercentualReducaoAcrescimo;
            IndicadorLiquidacao = pListOrdem[0].IndicadorLiquidacao;

            for(int i=1; i<pListOrdem.Count; i++){
                
                if(ApelidoCliente != pListOrdem[i].ApelidoCliente){
                    ApelidoCliente = string.Empty;
                }
                
                if(PercentualAcrescimoReducao != pListOrdem[i].PercentualReducaoAcrescimo){
                    PercentualAcrescimoReducao = -1;
                }
                
                if(IndicadorLiquidacao != pListOrdem[i].IndicadorLiquidacao){
                    IndicadorLiquidacao = string.Empty;
                }
            }

            if(ApelidoCliente != string.Empty){
                Ordem.ApelidoCliente = ApelidoCliente;
            }
            
            if(PercentualAcrescimoReducao != -1){
                Ordem.PercentualReducaoAcrescimo = PercentualAcrescimoReducao;
            }
            
            if(IndicadorLiquidacao != string.Empty){
                Ordem.IndicadorLiquidacao = IndicadorLiquidacao;
            }

            View.ApresentarExpanderCliente();
        }

        /// <summary>
        /// Popula Expander de Ativo de acordo com a(s) linha(s) selecionada(s)
        /// </summary>
        /// <param name="pListOrdem"></param>
        public void CarregarExpanderAtivo(ModelCollection<Model.Ordem> pListOrdem){
            string Titulo, Descricao, Bolsa;
            int? CodigoCarteira, VencimentoTermo;
            EnumWrapper<Model.Enum.TipoNaturezaOperacao> NaturezaOperacao;
            EnumWrapper<Model.Enum.TipoMercado> Mercado;
            
            if(pListOrdem.Count < 1){
                return;
            }
            
            Titulo = pListOrdem[0].Titulo;
            NaturezaOperacao = pListOrdem[0].NaturezaOperacao;
            CodigoCarteira = pListOrdem[0].CodigoCarteira;
            Mercado = pListOrdem[0].TipoMercado;
            Bolsa = pListOrdem[0].Bolsa;
            VencimentoTermo = pListOrdem[0].VencimentoTermo;

            for(int i=1; i<pListOrdem.Count; i++){
                if(Titulo != pListOrdem[i].Titulo){
                    Titulo = string.Empty;
                }
                
                if(NaturezaOperacao != pListOrdem[i].NaturezaOperacao){
                    NaturezaOperacao = null;
                }
                
                if(CodigoCarteira != pListOrdem[i].CodigoCarteira){
                    CodigoCarteira = null;
                }
                
                if(Mercado != pListOrdem[i].TipoMercado){
                    Mercado = null;
                }
                
                if(Bolsa != pListOrdem[i].Bolsa){
                    Bolsa = string.Empty;
                }
                
                if(VencimentoTermo != pListOrdem[i].VencimentoTermo){
                    VencimentoTermo = null;
                }
            }

            Ordem.Titulo = Titulo;
            
            if(NaturezaOperacao != null){
                Ordem.NaturezaOperacao = NaturezaOperacao;
            }
            
            Ordem.CodigoCarteira = CodigoCarteira;
            
            if(Mercado != null){
                Ordem.TipoMercado = Mercado;
            }
            
            Ordem.Bolsa = Bolsa;
            
            if(VencimentoTermo != null){
                Ordem.VencimentoTermo = VencimentoTermo;
            }

            View.ApresentarExpanderAtivo();
        }

        /// <summary>
        /// Popula Expander de Quantidade de acordo com a(s) linha(s) selecionada(s)
        /// </summary>
        /// <param name="pListOrdem"></param>
        public void CarregarExpanderQuantidade(ModelCollection<Model.Ordem> pListOrdem){
            decimal? Quantidade, QuatidadeCasada, QuantidadeAnexo4, QuantidadeAnexo5;
            decimal? Preco, ValorOrdem, valorDolar;
            
            if(pListOrdem.Count < 1){
                return;
            }
            
            Quantidade = pListOrdem[0].Quantidade;
            QuatidadeCasada = pListOrdem[0].QuantidadeCasada;
            QuantidadeAnexo4 = pListOrdem[0].QuantidadeAnexo4;
            QuantidadeAnexo5 = pListOrdem[0].QuantidadeAnexo5;
            Preco = pListOrdem[0].Preco;
            ValorOrdem = pListOrdem[0].ValorOrdem;
            valorDolar = pListOrdem[0].valorDolar;
            
            for(int i=1; i<pListOrdem.Count; i++){
                if(Quantidade != pListOrdem[i].Quantidade){
                    Quantidade = null;
                }
                
                if(QuantidadeAnexo4 != pListOrdem[i].QuantidadeAnexo4){
                    QuantidadeAnexo4 = null;
                }
                
                if(QuantidadeAnexo5 != pListOrdem[i].QuantidadeAnexo5){
                    QuantidadeAnexo5 = null;
                }
                
                if(QuatidadeCasada != pListOrdem[i].QuantidadeCasada){
                    QuatidadeCasada = null;
                }
                
                if(Preco != pListOrdem[i].Preco){
                    Preco = null;
                }
                
                if(ValorOrdem != pListOrdem[i].ValorOrdem){
                    ValorOrdem = null;
                }
                
                if(valorDolar != pListOrdem[i].valorDolar){
                    valorDolar = null;
                }
            }
            
            Ordem.Quantidade = Quantidade;
            Ordem.QuantidadeCasada = QuatidadeCasada;
            Ordem.QuantidadeAnexo4 = QuantidadeAnexo4;
            Ordem.QuantidadeAnexo5 = QuantidadeAnexo5;
            Ordem.Preco = Preco;
            Ordem.ValorOrdem = ValorOrdem;
            Ordem.valorDolar = valorDolar;
            
            View.ApresentarExpanderQuantidade();
        }

        /// <summary>
        /// Recupera o IndicadorDigitoClienteVerificador para verificar se é neccessario mostrar esse campo
        /// </summary>
        public void HabilitaDigitoClienteVerificador(){
            Communication.Parametro objComParametro = new Sinacor.UI.Bovespa.Ordens.Communication.Parametro(this.Session);
            Model.Parametro objParametro = objComParametro.RecuperarIndicadorDigitoCliente();
            DigitoClienteVerificador = objParametro.IndicadorDigitoCliente.ToUpper() == "S" ? true : false;
            View.ApresentarDigitoClienteVerificador();
        }

        /// <summary>
        /// rn: Se a célula <<SituaçãoOrdem>> for <<E>> (Ordem aberta por negócio de Exercício de Opções), desabilitar todos os controles da ViewSmartClient::ManutençãoOrdens, impedindo alterações;
        /// </summary>
        /// <param name="pListOrdem"></param>
        public void VerificarSituacaoOrdem(ModelCollection<Model.Ordem> pListOrdem){
            for(int i=0; i<pListOrdem.Count; i++){
                if(pListOrdem[i].Situacao.ToUpper() == "E"){
                    View.DesabilitarCampos();
                    break;
                }
            }
        }

        /// <summary>
        /// RN: 4. Verificar se a Ordem informada na seleção foi aberta pelo sinal de ofertas do Megabolsa:
        /// 4.1. Se Sim, 
        /// 4.1.1. Executar o evento desabilita() do GridManutençãoOrdens::Ordens, passando com parâmetros a ação <<desabilitar>> e as células <<Mercado>>, <<Quantidade>>, <<Ativo>>, <<NaturezaOperação>>, <<Bolsa>>, <<Validade>> e <<TipoOrdem>>, desde que <<TipoOrdem>> NÃO seja Discricionária;
        /// 4.1.2. Executar o evento desabilita() do Expander::Ordem, passando com parâmetros a ação <<desabilitar>> e os controles <<Expander::Ordem::CamposOrdem::Validade>>e <<Expander::Ordem::CheckBoxTipoOrdem>>, menos <<TipoOrdem>>Discricionária;
        /// 4.1.3. Executar o evento desabilita() do Expander::Quantidade, passando com parâmetros a ação <<desabilitar>> e o controle <<Expander::Quantidade::CamposQuantidade::Quantidade>>;
        /// 4.1.4. Executar o evento desabilita() do Expander::Ativo, passando com parâmetros a ação <<desabilitar>> e os controles <<Expander::Ativo::CamposAtivo::Ativo>>, <<Expander::Ativo::CamposAtivo::Bolsa>>, <<Expander::Ativo::CamposAtivo::NaturezaOperação>> e <<Expander::Ativo::RadioBoxAtivo::Mercado>>;
        /// </summary>
        /// <param name="pListOrdem"></param>
        public void VerificarOrdemMegaBolsa(ModelCollection<Model.Ordem> pListOrdem){
            bool flagOrdemDiscricionaria = false;
            for(int i=0; i<pListOrdem.Count; i++){
                if(pListOrdem[i].OrdemMegaBolsa){
                    for(int c=0; c<pListOrdem[i].TipoOrdem.Count; c++){
                        if(pListOrdem[i].TipoOrdem[c] != Model.Enum.TipoOrdem.Discricionaria){
                            flagOrdemDiscricionaria = true;
                        }
                    }

                    if(flagOrdemDiscricionaria){
                        //4.1.1
                        View.DesabilitarCamposGridOrdemMegaBolsa();
                        flagOrdemDiscricionaria = false;
                    }

                    //4.1.2
                    View.DesabilitarCamposExpanderOrdemOrdemMegaBolsa();

                    //4.1.3
                    View.DesabilitarCamposExpanderQuantidadeOrdemMegaBolsa();

                    //4.1.4
                    View.DesabilitarCamposExpanderAtivoOrdemMegaBolsa();
                }
            }
        }

        /// <summary>
        /// 5. Verificar se a Ordem informada na seleção é Administrada Concorrente e se está distribuída:
        /// 5.1. Se Sim, 
        /// 5.1.1. Desabilitar todos os controles da ViewSmartClient::ManutençãoOrdens, impedindo alterações;
        /// </summary>
        public void VerificarOrdemAdministradaDistribuida(ModelCollection<Model.Ordem> pListOrdem){
            for(int i=0; i<pListOrdem.Count; i++){
                for(int c=0; c<pListOrdem.Count; c++){
                    if(pListOrdem[i].TipoOrdem[c].Value == Sinacor.UI.Bovespa.Ordens.Model.Enum.TipoOrdem.Administrada && pListOrdem[i].IndicadorDistribuicao.ToUpper() != "N"){
                        View.DesabilitarCampos();
                        break;
                    }
                }
            }
        }

        /// <summary>
        /// Metodo responsavel parar ver se o usuário ter permissão de manipular a ordem
        /// RN
        /// 6. Se o usuário tiver permissão para alteração do Percentual de Acréscimo/Redução,
        /// 6.1. Habilitar a célula GridManutençãoOrdens::Ordens::PercentualAcréscimoRedução, permitindo sua alteração;
        /// 7. Se o usuário NÃO tiver permissão para alteração do Ativo da Ordem,
        /// 7.1. Desabilitar a célula GridManutençãoOrdens::Ordens::Ativo, impedindo sua alteração;
        /// 7.2. Executar o evento desabilita() do Expander::Ativo, passando os parâmetros <<Ativo>> para campo e <<desabilitar>> para a ação :
        /// 8. Se o usuário NÃO tiver permissão para alteração da Quantidade da Ordem,
        /// 8.1. Desabilitar a célula GridManutençãoOrdens::Ordens::Quantidade, impedindo sua alteração;
        /// 8.2. Executar o evento desabilita() do Expander::Quantidade, passando os parâmetros <<Quantidade>> para campo e <<desabilitar>> para a ação :
        /// </summary>
        public void VerificarPermissaoControle(){
            //6
            if(PermissaoAlterarPercentualAcrescimo){
                View.HabilitarPercentualAcrescimo();
            }else{
                View.DesabilitarPercentualAcrescimo();
            }

            //8
            if(PermissaoAlterarQuantidadeOrdem){
                View.HabilitarQuantidadeOrdem();
            }else{
                View.DesabilitarQuantidadeOrdem();
            }

            //7
            if(PermissaoAlterarAtivoOrdem){
                View.HabilitarAtivoOrdem();
            }else{
                View.DesabilitarAtivoOrdem();
            }

            //permissão de alteração de ordem
            if(!PermissaoAlterar){
                //COMENTADO PARA EFETUAR TESTES
                //View.DesabilitarCampos();
            }
        }

        /// <summary>
        /// 17. Verificar se todas as Ordens selecionadas são Administradas Concorrentes e se ainda Não estão fechadas:
        /// 17.1. Se SIM, habilitar a opção "Fechar Ordem Administrada Concorrente" do menú de contexto do Grid::ManutençãoOrdens::Ordens;
        /// 17.2. Se NÃO, ocultar a opção "Fechar Ordem Administrada Concorrente" do menú de contexto do Grid::ManutençãoOrdens::Ordens;
        /// </summary>
        /// <param name="pListOrdem"></param>
        public bool VerificarOrdemAdministradaConcorrente(ModelCollection<Model.Ordem> pListOrdem){
            bool flagAdministradaConcorrente = true;

            for(int i=0; i<pListOrdem.Count; i++){
                for(int c=0; c<pListOrdem[i].TipoOrdem.Count; c++){
                    if(pListOrdem[i].TipoOrdem[c].Value != Sinacor.UI.Bovespa.Ordens.Model.Enum.TipoOrdem.Administrada){
                        flagAdministradaConcorrente = false;
                        break;
                    }else if(pListOrdem[i].IndicadorDistribuicao != null){
                        if(pListOrdem[i].IndicadorDistribuicao == "A" || pListOrdem[i].IndicadorDistribuicao == "C"){
                            flagAdministradaConcorrente = false;
                            break;
                        }
                    }
                }
                if(!flagAdministradaConcorrente){
                    break;
                }
            }

            if(flagAdministradaConcorrente){
                View.ApresentarFecharOrdemAdministradaConcorrente();
                return true;
            }else{
                View.EsconderFecharOrdemAdministradaConcorrente();
                return false;
            }
        }

        /// <summary>
        /// Espera as Ordens para realiza o fechamento
        /// </summary>
        /// <param name="pListOrdem"></param>
        public void FecharOrdem(ModelCollection<Model.Ordem> pListOrdem){
            Communication.Ordem objCommOrdem = new Sinacor.UI.Bovespa.Ordens.Communication.Ordem(this.Session);
            ModelCollection<Model.Parameter.FecharOrdem> objListFecharOrdem = new ModelCollection<Sinacor.UI.Bovespa.Ordens.Model.Parameter.FecharOrdem>();
            Model.Parameter.FecharOrdem objFecharOrdem;
            try{
                for(int i=0; i<pListOrdem.Count; i++){
                    objFecharOrdem = new Sinacor.UI.Bovespa.Ordens.Model.Parameter.FecharOrdem();
                    
                    objFecharOrdem.DataOrdem = Convert.ToDateTime(pListOrdem[i].DataOrdem.Value);
                    objFecharOrdem.NumeroOrdem = Convert.ToInt32(pListOrdem[i].NumeroOrdem.Value);
                    objFecharOrdem.NumeroOrdemSubSequencia = Convert.ToInt32(pListOrdem[i].NumeroOrdemSequencia.Value);
                    
                    objListFecharOrdem.Add(objFecharOrdem);
                }

                objCommOrdem.FecharOrdem(objListFecharOrdem);
            }catch(Exception ex){
                HandleException(ex);
            }
        }

        /// <summary>
        /// Verifica qual o status da ordem para que poder apresentar a cor certa da linha
        /// </summary>
        /// <param name="pOrdem"></param>
        public void InformarStatusOrdem(Model.Ordem pOrdem){
            if(pOrdem.Situacao != "D"){
                if(pOrdem.QuantidadeCasada > 0){
                    if(pOrdem.QuantidadeCasada == pOrdem.Quantidade){
                        View.InformarOrdemCasada();
                    }else{
                        View.InformarOrdemCasadaParcialmente();
                    }
                }else{
                    View.InformarOrdemNaoCasada();
                }
            }else{
                View.InformarOrdemDesativada();
            }
        }

        /// <summary>
        /// Valida o codigo do titulo digitado
        /// </summary>
        /// <param name="pCodigoTitulo"></param>
        public bool ValidarTitulo(Model.Titulo pTitulo){
            Communication.Titulo objCommTitulo = new Sinacor.UI.Bovespa.Ordens.Communication.Titulo(this.Session);
            Model.Titulo objTitulo = new Sinacor.UI.Bovespa.Ordens.Model.Titulo();
            try{
                objTitulo.Codigo = pTitulo.Codigo;
                objTitulo.DataPregao = pTitulo.DataPregao;
                objTitulo = objCommTitulo.ConsultarTituloCodigo(objTitulo);
                if(objTitulo == null){
                    View.InformarAtivoInexistente();
                    return false;
                }else{
                    return true;
                }
            }catch(Exception ex){
                HandleException(ex);
            }
            return false;
        }

        /// <summary>
        /// Carregar Justificativa
        /// </summary>
        /// <param name="pConsultarJustificativa"></param>
        public void CarregarJustificativa(Model.Parameter.ConsultarJustificativa pConsultarJustificativa){
            try{
                Communication.Ordem objCommOrdem = new Sinacor.UI.Bovespa.Ordens.Communication.Ordem(this.Session);

                ListJustificativa = objCommOrdem.ConsultarJustificativa(pConsultarJustificativa);

                View.ApresentarJustificativa();
            }catch(Exception ex){
                HandleException(ex);
            }
        }

        /// <summary>
        /// Carregar Justificativa Padrao
        /// </summary>
        public void CarregarJustificativaPadrao(){
            Communication.Ordem objCommOrdem = new Sinacor.UI.Bovespa.Ordens.Communication.Ordem(this.Session);

            ListJustificativaPadrao = objCommOrdem.ConsultarJustificativaPadrao();

            View.ApresentarJustificativaPadrao();
        }

		/// <summary>
		/// Carregar com o Cadastro de Emissores conforme o Cliente informado na Ordem, quando o Cliente for Pessoa Jurídica e posicionar no Emissor Principal;
		/// </summary>
		public void CarregarEmissorOrdem(){
			Communication.Cliente objCommCliente = new Sinacor.UI.Bovespa.Ordens.Communication.Cliente(this.Session);

			
		}

        /// <summary>
        /// Limpa o grid de justificativas
        /// </summary>
        public void LimparJustificativa(){
            ListJustificativa = new ModelCollection<Sinacor.UI.Bovespa.Ordens.Model.Justificativa>();
            View.ApresentarJustificativa();
        }

        /// <summary>
        /// Preenche a propriedade Texto da model Justificativa e chama o apresentar justificativa texto
        /// </summary>
        /// <param name="pTexto"></param>
        public void PreencherJustificativaTexto(string pTexto){
            Justificativa.Texto = pTexto;
            View.ApresentarJustificativaTexto();
        }

        /// <summary>
        /// Carrega a observação referente a ordem
        /// </summary>
        /// <param name="pConsultarObservacao"></param>
        public void CarregarObservacao(Model.Parameter.ConsultarObservacao pConsultarObservacao){
            try{
                Communication.Ordem objCommOrdem = new Sinacor.UI.Bovespa.Ordens.Communication.Ordem(this.Session);
                
                Observacao = objCommOrdem.ConsultarObservacao(pConsultarObservacao);
                
                View.ApresentarObservacao();
            }catch(Exception ex){
                HandleException(ex);
            }
        }

        /// <summary>
        /// Preenche a propriedade Descrição de Observação e apresenta o dado
        /// </summary>
        /// <param name="pTexto"></param>
        public void PreencherObservacaoPadrao(string pTexto){
            Observacao.Descricao = pTexto;
            View.ApresentarObservacao();
        }

        /// <summary>
        /// Valida a Justificativa
        /// RN:
        /// 1. Se o tamanho do texto no controle for MENOR QUE 3, NULO ou VAZIO, quando eliminado os espaços, enviar a seguinte mensagem ao usuário:
        /// "Justificativa Obrigatória.";
        /// 2. Se Expander::Justificativa::GridJustificativas estiver visível e tem linha selecionada,
        /// 2.1. Atualizar a célula Expander::Justificativas::Justificativa::Justificativa com o texto do controle, para a linha selecionada;
        /// </summary>
        /// <param name="pJustificativa"></param>
        public void ValidarJustificativa(string pJustificativa, int pRowIndex){
            if(pJustificativa.Replace(" ", "").Length >= 3){
                ErroValidacao.Add("Bovespa.Ordens.Message.JustificativaObrigatoria");
                return;
            }

            if(pRowIndex > -1){
                ListJustificativa[pRowIndex].Texto = pJustificativa;
            }
        }

        /// <summary>
        /// 1. Gravar Expander::Justificativa::TextoJustificativa na base para todas as Ordens selecionadas
        ///     em GridManutençãoOrdens::Ordens e que tiveram modificações nos seus dados;
        /// 2. Se Expander::Justificativa::GridJustificativas estiver visível e tem linha selecionada,
        /// 2.1. Atualizar a base de Justificativas com os dados do Expander::Justificativa::GridJustificativas;
        /// </summary>
        public void SalvarJustificativa(ModelCollection<Model.Ordem> pListOrdem, int pRowIndex){
            try{
                Communication.Ordem objCommOrdem = new Sinacor.UI.Bovespa.Ordens.Communication.Ordem(this.Session);
                if(pRowIndex > -1){
                    //alteração
                    //para ser alteração só pode ser para uma ordem, pois o grid de justificativa não é carregado para multseleção
                    Model.Parameter.AlterarJustificativa objAlterarJustificativa = new Sinacor.UI.Bovespa.Ordens.Model.Parameter.AlterarJustificativa();
                    
                    objAlterarJustificativa.DataOrdem = Convert.ToDateTime(pListOrdem[0].DataOrdem.Value);
                    objAlterarJustificativa.IdentificadorJustificativa = ListJustificativa[pRowIndex].IdentificadorJustificativa;
                    objAlterarJustificativa.NumeroOrdem = Convert.ToInt32(pListOrdem[0].NumeroOrdem.Value);
                    objAlterarJustificativa.SubsequenciaOrdem = Convert.ToInt32(pListOrdem[0].NumeroOrdemSequencia.Value);
                    objAlterarJustificativa.TextoJustificativa = ListJustificativa[pRowIndex].Texto;
                    objCommOrdem.AlterarJustificativa(objAlterarJustificativa);
                }else{
                    //inclusão
                    Model.Parameter.IncluirJustificativa objIncluirJustificativa;
                    for(int i=0; i<pListOrdem.Count; i++){
                        objIncluirJustificativa = new Sinacor.UI.Bovespa.Ordens.Model.Parameter.IncluirJustificativa();

                        objIncluirJustificativa.CodigoCliente = pListOrdem[i].CodigoCliente == null ? 0 : Convert.ToInt32(pListOrdem[i].CodigoCliente);
                        objIncluirJustificativa.DataHoraOrdem = pListOrdem[i].HoraOrdem == null ? DateTime.MinValue : Convert.ToDateTime(pListOrdem[i].HoraOrdem);
                        objIncluirJustificativa.DataOrdem = Convert.ToDateTime(pListOrdem[i].DataOrdem.Value);
                        objIncluirJustificativa.NumeroOrdem = Convert.ToInt32(pListOrdem[i].NumeroOrdem.Value);
                        objIncluirJustificativa.SubsequenciaOrdem = Convert.ToInt32(pListOrdem[i].NumeroOrdemSequencia.Value);
                        objIncluirJustificativa.TextoJustificativa = Justificativa.Texto;

                        objCommOrdem.IncluirJustificativa(objIncluirJustificativa);
                    }
                }
            }catch(Exception ex){
                HandleException(ex);
            }
        }

        /// <summary>
        /// verificar_OrdemOriginal
        /// Se o campo ExpanderOrdem::OrdemOriginal for diferente de nulo ou 0 (zero), enviar a seguinte mensagem ao usuário:
        ///     "Ordem gerada por distribuição de Ordem Administrada Concorrente. Só pode ser cancelada pelo processo de cancelamento
        ///     de Distribuição da Ordem Administrada Concorrente Original."
        /// </summary>
        public void InformarOrdemGeradaDistribuicaoAdministradaConcorrenteCancelada(ModelCollection<Model.Ordem> pListOrdem){
            for(int i=0; i<pListOrdem.Count; i++){
                if(pListOrdem[i].NumeroOrdemOriginal != null && pListOrdem[i].NumeroOrdemOriginal != 0){
                    MensagemValidacao.Add("Bovespa.Ordens.Message.AlertaOrdemAdmConcorrenteCancelada");
                    break;
                }
            }
        }

        /// <summary>
        /// Verifica se existe inconsistencias paras a ordens
        /// Botao Salvar de Manutenção de Ordens.EAP
        /// 3. Verificar se a Ordem não possui inconsistências na recepção de ofertas do Megabolsa; Se possuir, enviar a seguinte mensagem ao usuário:
        ///     "Existem inconsistências na recepção de ofertas do Megabolsa para a Ordem Nº <<número da ordem>>, <<inconsistência>>.",
        ///     para todas as ordens que apresentarem inconsistências e incluir em arquivo-texto para apresentação ao usuário no final do processo de gravação,
        ///     para que se possa imprimir/copiar a relação de inconsistências apuradas;
        /// </summary>
        /// <param name="pListOrdem"></param>
        public void ConsultarOrdemInconsistencia(ModelCollection<Model.Ordem> pListOrdem){
            StringBuilder sb = new StringBuilder(string.Empty);
            Communication.Ordem objCommOrdem = new Sinacor.UI.Bovespa.Ordens.Communication.Ordem(this.Session);
            Model.Parameter.ConsultarOrdemInconsistencia objConsultarOrdemInconsistencia;
            ModelCollection<Model.OrdemInconsistencia> objListOrdemInconsistencia;
            
            try{
                for(int i=0; i<pListOrdem.Count; i++){
                    objConsultarOrdemInconsistencia = new Sinacor.UI.Bovespa.Ordens.Model.Parameter.ConsultarOrdemInconsistencia();
                    
                    objConsultarOrdemInconsistencia.DataOrdem = Convert.ToDateTime(pListOrdem[i].DataOrdem.Value);
                    objConsultarOrdemInconsistencia.NumeroOrdem = Convert.ToInt32(pListOrdem[i].NumeroOrdem.Value);
                    objConsultarOrdemInconsistencia.NumeroOrdemSubSequencia = Convert.ToInt32(pListOrdem[i].NumeroOrdemSequencia);
                    objListOrdemInconsistencia = objCommOrdem.ConsultarOrdemInconsistencia(objConsultarOrdemInconsistencia);
                    
                    if(objListOrdemInconsistencia == null){
                        continue;
                    }
                    
                    for(int c=0; c<objListOrdemInconsistencia.Count; c++){
                        sb.Append(ResourceProviderManager.GetResourceProvider().GetResource("Bovespa.Ordens.Message.ExisteOrdemInconsistente").ToString().Replace("{0}", objListOrdemInconsistencia[c].NumeroOrdem.ToString()).Replace("{1}", objListOrdemInconsistencia[c].DescricaoErro) + "\r\n\r\n");
                    }
                }
            }catch(Exception ex){
                HandleException(ex);
            }
            
            if(sb.ToString() == string.Empty){
                return;
            }
            
            MensagemValidacao.Add(sb.ToString());
            CriarArquivoTexto(sb.ToString());
        }

        /// <summary>
        /// Cria arquivo Texto a partir de um texto
        /// </summary>
        /// <param name="pTexto"></param>
        /// <returns></returns>
        private string CriarArquivoTexto(string pTexto){
            string sPath = System.Environment.GetFolderPath(Environment.SpecialFolder.Desktop) + "\\OrdemInconsistencia" + DateTime.Now.ToShortDateString().Replace(@"/", "").Replace(":", "") + " - " + DateTime.Now.ToShortTimeString().Replace(@"/", "").Replace(":", "") + ".txt";
            StreamWriter objStrWrt = new StreamWriter(sPath, false, Encoding.UTF8);
            objStrWrt.Write(pTexto);
            objStrWrt.Close();
            return sPath;
        }

        /// <summary>
        /// Verifica se o cliente esta bloqueado para este papel.
        /// RN: Botao Salvar de Manutenção de Ordens.EAP
        /// 4. Se estiver parametrizada a verificação de bloqueio de cliente, verificar o bloqueio para o Cliente, Mercado, Natureza de Operação,
        ///     Ativo e Pregão informados. Se a Data de Validade em ValidadeOrdem de CamposOrdem do Expander::Ordens for MENOR QUE a Data do Sistema,
        ///     utilizar a Data da Validade da Ordem e não a Data do Pregão, para fazer esta verificação;
        /// </summary>
        /// <param name="pListVerificarBloqueioCliente"></param>
        public void VerificarBloqueioCliente(ModelCollection<Model.Ordem> pListOrdem, DateTime? pDataValidade){
            try{
                Communication.Cliente objCommCliente = new Sinacor.UI.Bovespa.Ordens.Communication.Cliente(this.Session);
                
                bool flagUseDataValidade = false;
                if(pDataValidade != null){
                    if(pDataValidade < DateTime.Now.Date){
                        flagUseDataValidade = true;
                    }
                }
                ModelCollection<Model.Parameter.VerificarBloqueioCliente> objListVerificarBloqueio = new ModelCollection<Sinacor.UI.Bovespa.Ordens.Model.Parameter.VerificarBloqueioCliente>();
                Model.Parameter.VerificarBloqueioCliente objVerifcarBloqueio;
                for(int i=0; i<pListOrdem.Count; i++){
                    objVerifcarBloqueio = new Sinacor.UI.Bovespa.Ordens.Model.Parameter.VerificarBloqueioCliente();
                    
                    objVerifcarBloqueio.CodigoCliente = pListOrdem[i].CodigoCliente;
                    objVerifcarBloqueio.CodNegocio = pListOrdem[i].CodigoNegocio;
                    objVerifcarBloqueio.DataPregao = flagUseDataValidade ? pDataValidade : DateTime.Now;
                    objVerifcarBloqueio.Mercado = (Model.Enum.TipoMercado)pListOrdem[i].TipoMercado;
                    objVerifcarBloqueio.NaturezaOperacao = (Model.Enum.TipoNaturezaOperacao)pListOrdem[i].NaturezaOperacao;
                    
                    objListVerificarBloqueio.Add(objVerifcarBloqueio);
                }
                
                for(int i=0; i<objListVerificarBloqueio.Count; i++){
                    if(objCommCliente.VerificarBloqueioCliente(objListVerificarBloqueio[i]).isBloqueado){
                        //ErroValidacao.Add("ResourceKeyErroValidacao||Ver com Jose Dias");
                    }
                }
            }catch(Exception ex){
                HandleException(ex);
            }
        }

        /// <summary>
        /// Verifica se o há ordens com data retroativa e se o usuário tem permissão de altera-las
        /// RN: Botão salvar de Manutenção de Ordens.EAP
        /// 5. Se o campo ValidadeOrdem de CamposOrdem do Expander::Ordens for MENOR QUE a data do sistema, verificar se o
        ///     usuário tem permissão para manipular Ordens com esta característica. Se não, enviar a seguinte mensagem ao usuário:
        /// "Usuário NÃO tem permissão para manipular Ordens com Data de Validade anterior à Data do Sistema";
        /// </summary>
        /// <param name="pDataValidade"></param>
        public bool VerificarUsuarioPermissaoValidadeOrdemRetroativa(DateTime? pDataValidade){
            try{
                if(pDataValidade.HasValue){
                    if(pDataValidade.Value.Date < DateTime.Now.Date){
                        Communication.Acesso objCommAcesso = new Sinacor.UI.Bovespa.Ordens.Communication.Acesso(this.Session);
                        Model.Parameter.VeririfcarAcessoFuncao objAcessoFuncao = new Sinacor.UI.Bovespa.Ordens.Model.Parameter.VeririfcarAcessoFuncao();
                        objAcessoFuncao.Funcao = "D1SIM";
                        if(!objCommAcesso.ValidarAcessoFuncao(objAcessoFuncao)){
                            ErroValidacao.Add("Bovespa.Ordens.Message.NaoPermissaoDataRetroativa");
                            return false;
                        }
                    }
                }
            }catch(Exception ex){
                HandleException(ex);
            }
            return true;
        }

        /// <summary>
        /// Busca os financimanetos POPs relativos a ordem
        /// RN:
        /// 18.  Se NÃO houver mais do que uma linha selecionada,
        /// 18.1. Se o Tipo da Ordem selecionada for <<Financiamento>> ou <<Estratégia POP>>,
        /// 18.1.1. Executar o evento carrega_controles() de Expander::Financiamento/EstratégiaPOP, passando os parâmetros <<DataOrdem>> e <<NúmeroOrdem>> da
        ///     Ordem selecionada;
        /// 18.2. Se as condições NÃO forem atendidas, limpar Grid/Financiamento/EstratégiaPOP::Ordens;
        /// 18.2.1. Executar o evento contrair() do Expander::Financiamento/EstratégiaPOP;
        /// </summary>
        /// <param name="pConsultarOrdem"></param>
        public void CarregarFinanciamentoPOP(Model.Parameter.ConsultarOrdem pConsultarOrdem, Model.Ordem pOrdem){
            bool flagFinanciamentoPOP = false;
            for(int i=0; i<pOrdem.TipoOrdem.Count; i++){
                if(pOrdem.TipoOrdem[i].Value == Sinacor.UI.Bovespa.Ordens.Model.Enum.TipoOrdem.Financiamento){
                    flagFinanciamentoPOP = true;
                    break;
                }

                if(pOrdem.CodigoISIN != null){
                    if(pOrdem.CodigoISIN.Length > 7){
                        if(pOrdem.CodigoISIN.Substring(6, 2).ToUpper() == "PP"){
                            flagFinanciamentoPOP = true;
                            break;
                        }
                    }
                }
            }
            if(!flagFinanciamentoPOP){
                ListFinanciamentoPOP = new ModelCollection<Sinacor.UI.Bovespa.Ordens.Model.Ordem>();
                View.ApresentarFinanciamentoPOP();
                TotalizaCompraVendaFinanciamentoPOP();
                return;
            }

            Communication.Ordem objCommOrdem = new Sinacor.UI.Bovespa.Ordens.Communication.Ordem(this.Session);

            ListFinanciamentoPOP = objCommOrdem.ConsultarOrdem(pConsultarOrdem);

            View.ApresentarFinanciamentoPOP();
            
            TotalizaCompraVendaFinanciamentoPOP();
        }

        /// <summary>
        /// Limpa o grid de justificativas
        /// </summary>
        public void LimparFinanciamentoPOP(){
            ListFinanciamentoPOP = new ModelCollection<Sinacor.UI.Bovespa.Ordens.Model.Ordem>();
            View.ApresentarFinanciamentoPOP();
            
            FinanciamentoPOPCompra = new Sinacor.UI.Bovespa.Ordens.Model.Ordem();
            FinanciamentoPOPVenda = new Sinacor.UI.Bovespa.Ordens.Model.Ordem();
            View.ApresentarTotalCompra();
            View.ApresentarTotalVenda();
        }

        /// <summary>
        /// Verifica qual o status da ordem para que poder apresentar a cor certa da linha, para o grid de Financiamento POP
        /// </summary>
        /// <param name="pOrdem"></param>
        public void InformarStatusOrdemFinanciamentoPOP(Model.Ordem pOrdem){
            if(pOrdem.Situacao != "D"){
                if(pOrdem.QuantidadeCasada > 0){
                    if(pOrdem.QuantidadeCasada == pOrdem.Quantidade){
                        View.InformarOrdemCasadaFinanciamentoPOP();
                    }else{
                        View.InformarOrdemCasadaParcialmenteFinanciamentoPOP();
                    }
                }else{
                    View.InformarOrdemNaoCasadaFinanciamentoPOP();
                }
            }else{
                View.InformarOrdemDesativadaFinanciamentoPOP();
            }
        }

        /// <summary>
        /// Sumariza os resultados de finaciamento POP para mostrar o total de venda e compra.
        /// RN: ExpanderFinanciamentoPOP:Campos - Manutenção Orden.EAP
        /// Somar a coluna GridFinanciamento/EstratégiaPOP::QuantidadeNegócio de todas as linhas do grid, para célula
        ///     GridFinanciamento/EstratégiaPOP::NaturezaOperação = "C" e atribuir o resultado a CamposFinanciamento/EstratégiaPOP::TotalCompra;
        /// Somar a coluna GridFinanciamento/EstratégiaPOP::QuantidadeNegócio de todas as linhas do grid, para célula
        ///     GridFinanciamento/EstratégiaPOP::NaturezaOperação = "V" e atribuir o resultado a CamposFinanciamento/EstratégiaPOP::TotalVenda;
        /// </summary>
        public void TotalizaCompraVendaFinanciamentoPOP(){
            FinanciamentoPOPCompra = new Sinacor.UI.Bovespa.Ordens.Model.Ordem();
            FinanciamentoPOPVenda = new Sinacor.UI.Bovespa.Ordens.Model.Ordem();
            FinanciamentoPOPVenda.Quantidade = 0;
            FinanciamentoPOPCompra.Quantidade = 0;

            for(int i=0; i<ListFinanciamentoPOP.Count; i++){
                if(ListFinanciamentoPOP[i].NaturezaOperacao.Value == Sinacor.UI.Bovespa.Ordens.Model.Enum.TipoNaturezaOperacao.Compra){
                    FinanciamentoPOPCompra.Quantidade += ListFinanciamentoPOP[i].Quantidade;
                }
                
                if(ListFinanciamentoPOP[i].NaturezaOperacao.Value == Sinacor.UI.Bovespa.Ordens.Model.Enum.TipoNaturezaOperacao.Venda){
                    FinanciamentoPOPVenda.Quantidade += ListFinanciamentoPOP[i].Quantidade;
                }
            }
            View.ApresentarTotalCompra();
            View.ApresentarTotalVenda();
        }

        /// <summary>
        /// Realiza o casamento das ordens
        /// RN: Expander Financiamento POP - Grid Financiamento POP - Manutencao Ordens.EAP
        /// 1. Verificar se o sistema está aberto, ou seja, foi executado o Procedimento de Abertura do Sistema. Não estando aberto, não é possível executar o Casamento da Subsequência da Ordem. Enviar a seguinte mensagem ao usuário:
        /// "O Sistema DEVE estar aberto para execução desta rotina";
        /// 2. Solicitar a confirmação do usuário para a data de casamento, com a seguinte mensagem:
        /// "Confirma o Casamento da Subsequência para a Data <<CamposManutençãoOrdens::DataPregão>>, indicada na Data do Pregão para o Pré-Boleto?"
        /// 2.1. Se Sim, executar rotina de casamento das subsequências da Ordem;
        /// 2.2. Se Não, posicionar o cursor em CamposManutençãoOrdens::DataPregão, para alteração da data para o casamento;
        /// 3. Executar o evento inicializa() de GridFinanciamento/EstratégiaPOP::Ordens;
        /// </summary>
        /// <param name="pListOrdem"></param>
        public void CasarOrdem(Model.Ordem pOrdem, ModelCollection<Model.Ordem> pListOrdem, DateTime pDataPregao){
            string sErroValidacao = string.Empty;
            Communication.Negocio objCommNegocio = new Sinacor.UI.Bovespa.Ordens.Communication.Negocio(this.Session);
            try{
                if(!objCommNegocio.SistemaAberto()){
                    View.InformarSistemaFechado();
                    return;
                }

                //Bovespa.Ordens.Message.ConfirmaCasamentoSubSequenciaDataPregao
                if(!View.ConfirmarCasamentoSubSequenciaDataPregao()){
                    //Habilita a Alteração da Data do Pregão
                    View.HabilitarDataPregao();
                    return;
                }
                View.DesabilitarDataPregao();

                //chamar o metodo RealizarCasamento de Communication.PreBoleto
                Model.Enum.TipoCasamentoPreBoleto objEnumTipoCasamentoPreBoleto = new Sinacor.UI.Bovespa.Ordens.Model.Enum.TipoCasamentoPreBoleto();
                for(int i=0; i<pOrdem.TipoOrdem.Count; i++){
                    if(pOrdem.TipoOrdem[i].Value == Sinacor.UI.Bovespa.Ordens.Model.Enum.TipoOrdem.Financiamento){
                        objEnumTipoCasamentoPreBoleto = Sinacor.UI.Bovespa.Ordens.Model.Enum.TipoCasamentoPreBoleto.FIN;
                    }
                }
                if(pOrdem.CodigoISIN != null){
                    if(pOrdem.CodigoISIN.Length > 7){
                        if(pOrdem.CodigoISIN.Substring(6, 2).ToUpper() == "PP"){
                            objEnumTipoCasamentoPreBoleto = Sinacor.UI.Bovespa.Ordens.Model.Enum.TipoCasamentoPreBoleto.ESP;
                        }
                    }
                }

                MensagemValidacao = new List<string>();
                Model.Parameter.RealizarCasamentoPreBoleto objRealizarCasamentoPreBoleto;
                Model.RealizarCasamento objRealizarCasamento;
                Communication.PreBoleto objPreBoleto = new Sinacor.UI.Bovespa.Ordens.Communication.PreBoleto(this.Session);
                for(int i=0; i<pListOrdem.Count; i++){
                    objRealizarCasamentoPreBoleto = new Sinacor.UI.Bovespa.Ordens.Model.Parameter.RealizarCasamentoPreBoleto();
                    objRealizarCasamentoPreBoleto.DataOrdem = Convert.ToDateTime(pListOrdem[i].DataOrdem.Value);
                    objRealizarCasamentoPreBoleto.DataPregao = pDataPregao;
                    objRealizarCasamentoPreBoleto.NumeroOrdem = Convert.ToInt32(pListOrdem[i].NumeroOrdem.Value);
                    objRealizarCasamentoPreBoleto.NumeroOrdemSequencia = Convert.ToInt32(pListOrdem[i].NumeroOrdemSequencia.Value);

                    objRealizarCasamento = objPreBoleto.RealizarCasamentoPreBoleto(objRealizarCasamentoPreBoleto, objEnumTipoCasamentoPreBoleto);

                    //verifica as mensagens
                    if(objRealizarCasamento.MensagemCasamento.Descricao != string.Empty){
                        MensagemValidacao.Add(objRealizarCasamento.MensagemCasamento.Descricao);
                    }

                    if(objRealizarCasamento.MensagemVerificacaoSaldo.Descricao != string.Empty){
                        MensagemValidacao.Add(objRealizarCasamento.MensagemVerificacaoSaldo.Descricao);
                    }

                    if(objRealizarCasamento.MensagemVerificacaoCompliance.Descricao != string.Empty){
                        MensagemValidacao.Add(objRealizarCasamento.MensagemVerificacaoCompliance.Descricao);
                    }
                    MensagemValidacao.Add(objRealizarCasamento.TipoRetornoCasamento.ToString());
                }

                View.ApresentarMensagemValidacao();
            }catch(Exception ex){
                HandleException(ex);
            }
        }

        public void SalvarFinanciamentoPOP(Model.Ordem pOrdem, ModelCollection<Model.Ordem> pListOrdemSubSequencia){
            
        }

        /// <summary>
        /// 1. Se GridManutençãoOrdens::Ordens::Validade for MENOR QUE a data do sistema, verificar se o usuário tem permissão para manipular Ordens com esta característica. Se não, enviar a seguinte mensagem ao usuário:
		/// "Usuário NÃO tem permissão para manipular Ordens com Data de Validade anterior à Data do Sistema";
		/// 2. Se GridManutençãoOrdens::DataOrdem for MENOR QUE a menor data do Calendário de Pregões, verificar:
		/// 2.1. Se a Subsequência da Ordem está casada (GridFinanciamento/EstratégiaPOP::Ordens::QuantidadeCasada > 0) e possui data de casamento MENOR QUE a menor data do Calendário de Pregões, a Subsequência da Ordem NÃO pode ser Cancelada. Enviar a seguinte mensagem ao usuário:
		/// "Subsequência da Ordem NÃO pode ser cancelada pois possui casamento anterior ao Calendário do Sistema";
		/// 3. A Subsequêcnia da Ordem NÃO pode ter sido aberta pelo processo de Abertura de Ordens pela mensageria de Ofertas do Megabolsa. Se sim, enviar a seguinte mensagem ao usuário:;
		/// "Subsequência da Ordem aberta pelo processo de Abertura de Ordens pela mensageria de Ofertas do Megabolsa Não pode ser Cancelada";
		/// 4. Verificar se o sistema está aberto, ou seja, foi executado o Procedimento de Abertura do Sistema. Não estando aberto, não é possível executar o Cancelamento da Subsequência da Ordem. Enviar a seguinte mensagem ao usuário:
		/// "O Sistema DEVE estar aberto para execução desta rotina";
		/// 5. Se a Subsequência da Ordem estiver casada (GridFinanciamento/EstratégiaPOP::Ordens::QuantidadeCasada > 0), efetuar o descasamento;
		/// 6. Executar o Cancelamento da Subsequência da Ordem, alterando a Situação para <<D>>;
		/// 7. Se a Subsequência da Ordem estava casada antes do Cancelamento, executar o Cálculo Financeiro do Cliente da Ordem para cada pregão descasado;
		/// 7.1. Se o sistema está parametrizado para efetuar verificação de saldo negociável, efetuar a verificação, independente da Natureza da Operação, e enviar a mensagem recebida da rotina de verificação de saldo negociável ao usuário;
        /// </summary>
        /// <param name="pOrdem"></param>
        /// <param name="pListOrdemSubSequencia"></param>
        public void CancelarOrdemFinanciamentoPOP(Model.Ordem pOrdem, ModelCollection<Model.Ordem> pListOrdemSubSequencia){
            Communication.Negocio objCommNegocio = new Sinacor.UI.Bovespa.Ordens.Communication.Negocio(this.Session);
            
            if(!objCommNegocio.SistemaAberto()){
				ResourceKey = "Bovespa.Ordens.Message.SistemaAberto";
				View.InformarSistemaFechado();
				return;
            }

            if(!VerificarUsuarioPermissaoValidadeOrdemRetroativa(pOrdem.DataValidade)){
                return;
            }

			Model.Parameter.ConsultarNegocioExecutado objConsultarNegocioExecutado = new Sinacor.UI.Bovespa.Ordens.Model.Parameter.ConsultarNegocioExecutado();
			objConsultarNegocioExecutado.DataOrdem = Convert.ToDateTime(pOrdem.DataOrdem.Value);
			objConsultarNegocioExecutado.NumeroOrdem = Convert.ToInt32(pOrdem.NumeroOrdem.Value);
			objConsultarNegocioExecutado.NumeroOrdemSubSequencia = Convert.ToInt32(pOrdem.NumeroOrdemSequencia.Value);
			ModelCollection<Model.NegocioExecutado> objListNegocioExecutado = objCommNegocio.ConsultarNegocioExecutado(objConsultarNegocioExecutado);
			bool flagDataCasamentoMenorPregao = false;
			if(objListNegocioExecutado != null){
				if(objListNegocioExecutado.Count > 0){
					if(objListNegocioExecutado[0].DataNegocio.Date < DataPregao.Date){
						flagDataCasamentoMenorPregao = true;
					}
				}
			}
			
            for(int i=0; i<pListOrdemSubSequencia.Count; i++){
                if(pOrdem.DataOrdem < DataPregao){
					if(pListOrdemSubSequencia[i].QuantidadeCasada > 0){
						if(flagDataCasamentoMenorPregao){
							MensagemValidacao.Add("Bovespa.Ordens.Message.SubSequenciaOrdemNaoCanceladaPossuiCasamento");
							continue;
						}
					}
                }
            }
            
            //falar com nemir para finalizar o resto da regra de cancelamento.
        }

        /// <summary>
        /// 1. Verificar se o Cliente pertence ao grupo de assessores do usuário logado e também se está cadastrado e ativo; se não, enviar a seguinte mensagem ao usuário:
		/// "Cliente Não Cadastrado, desativado ou Não Disponível para o operador.";
		/// 1.1. Caso contrário, atribuir o Dígito Verificador do Cliente a Expander::Cliente::CamposCliente::DígitoCliente;
		/// 2. O Cliente só pode ser alterado se o usuário tiver permissão;
		/// 3. Se o Cliente for Administrado Concorrente e o sistema estiver parametrizado para utilização de Administrado Concorrente, 
		/// 3.1. Marcar e executar o evento click() do Expander::Cliente::CheckBoxCliente::AdministradoConcorrente;
		/// 3.2. Executar evento habilita() do Expander::Ordem::CheckBoxTipoOrdem, passando como parâmetros os controles <<Administrada>> e <<Discricionária>>;
		/// 3.3. Executar evento desabilita() do Expander::Ordem::CheckBoxTipoOrdem, passando como parâmetros os controles <<Limitada>>, <<OnStop>>, <<Mercado>>, <<Financiamento>> e <<Casada>>;
		/// 4. Se o Cliente NÃO for Administrado Concorrente, executar o evento desabilita() do Expander::Cliente::CheckBoxCliente::AdministradoConcorrente;
		/// 5. Verificar o método de cobrança de corretagem do Cliente:
		/// 5.1. Se for pelo Custo Total, atribuir o percentual de Custo Total ao Expander::Cliente::CamposCliente::PercentualAcréscimoRedução;
		/// 5.2. Se não for, atribuir o percentual de redução/acréscimo do Cadastro do Cliente;
		/// 6. Atribuir o broker do Cadastro do Cliente ao Expander::Cliente::CamposCliente::Broker;
		/// 7. Se o Cliente for Pessoa Vinculada,
		/// 7.1. Marcar o Expander::Cliente::CheckBoxCliente::PessoaVinculada;
		/// 7.2. Se Não, desmarcar o Expander::Cliente::CheckBoxCliente::PessoaVinculada;
		/// 8. Se o preenchimento automático do Tipo de Liquidação estiver parametrizado no sistema e o
		///		Mercado NÃO for Derivativo e o Cliente possui Custodiante ou Usuário Institucional, 
		/// 8.1. Atribuir <<C>> ao Expander::Cliente::CamposCliente::TipoLiquidação;
		/// 8.2. Caso contrário atribuir NULO;
		/// 9. Se o Cliente informado for Broker (principal ou intermediário), marcar Expander::Cliente::CheckBoxCliente::TipoOrdem::Discricionária;
		/// 10. Atribuir a Expander::Cliente::CamposCliente::NomeCliente o Nome + o Complemento do Nome do Cadastro do Cliente;
		/// 11. Executar o evento carrega_controle do Expander::Cliente::CamposCliente::Emissor;
		/// 12. Se o Cliente informado for Qualificado, 
		/// 12.1. Executar o evento valida() do Expander::Ativo::CamposAtivo::Bolsa; 
		/// 13. Executar o evento célula_atualizar de GridManutençãoOrdens::Ordens, passando como parâmetros <<Cliente>> para a célula e <<Expander::Cliente::CamposCliente::ApelidoCliente>> como valor;
        /// </summary>
        /// <param name="pOrdem"></param>
        /// <param name="pAlteracao"></param>
        public bool ValidarCliente(bool pAlteracao){
			Communication.Cliente objCommCliente = new Sinacor.UI.Bovespa.Ordens.Communication.Cliente(this.Session);
			Model.Parameter.ConsultarClientePorCodigoRequest objConsultarClientePorCodigo = new Sinacor.UI.Bovespa.Ordens.Model.Parameter.ConsultarClientePorCodigoRequest();
			Model.Parameter.ValidarClienteRequest objValidarCliente = new Sinacor.UI.Bovespa.Ordens.Model.Parameter.ValidarClienteRequest();
			Model.Parameter.ConsultarClienteRequest objConsultarCliente = new Sinacor.UI.Bovespa.Ordens.Model.Parameter.ConsultarClienteRequest();

			//verifica se foi preenchido o ApelidoCLiente
			if(Ordem.ApelidoCliente.Trim() == string.Empty){
				View.InformarClienteInvalidoDesativadoNaoDisponivel();
				return false;
			}

			objConsultarCliente.Apelido = Ordem.ApelidoCliente;
			ModelCollection<Model.Cliente> objListCliente;
			try{
				objListCliente = objCommCliente.ConsultarCliente(objConsultarCliente);
			}catch(BusinessException){
				objListCliente = null;
			}
			if(objListCliente == null){
				View.InformarClienteInvalidoDesativadoNaoDisponivel();
				return false;
			}else if(objListCliente.Count < 1){
				View.InformarClienteInvalidoDesativadoNaoDisponivel();
				return false;
			}

			objValidarCliente.CodigoCliente = Convert.ToInt32(objListCliente[0].Codigo.Value);
			objValidarCliente.CodigoClienteOrdem = Convert.ToInt32(objListCliente[0].Codigo.Value);
			//objValidarCliente.TipoOrdem = new Sinacor.UI.Bovespa.Ordens.Model.Enum.TipoOrdem();
			if(!objCommCliente.ValidarCliente(objValidarCliente).IsValid){
				View.InformarClienteInvalidoDesativadoNaoDisponivel();
				return false;
			}

			if(pAlteracao){
				Communication.Acesso objCommunicationAcesso = new Sinacor.UI.Bovespa.Ordens.Communication.Acesso(this.Session);
				Model.Parameter.VeririfcarAcessoFuncao objVerificarAcesso = new Sinacor.UI.Bovespa.Ordens.Model.Parameter.VeririfcarAcessoFuncao();
				objVerificarAcesso.Funcao = "ACLI";
				if(!objCommunicationAcesso.ValidarAcessoFuncao(objVerificarAcesso)){
					View.InformarUsuarioSemPermissaoAlterarCliente();
					return false;
				}
			}

			Communication.Parametro objCommPar = new Sinacor.UI.Bovespa.Ordens.Communication.Parametro(this.Session);
			if(objCommPar.RecuperarAdministradorConcorrente().ToUpper() == "S" && objListCliente[0].IsAdministradoCOncorrente){
				View.DesabilitarExpanderAtivoNaturezaOperacao();
			}else{
				View.HabilitarExpanderAtivoNaturezaOperacao();
			}

			if(!objListCliente[0].IsAdministradoCOncorrente){
				View.DesabilitarExpanderClienteAdministradoConcorrente();
			}else{
				View.HabilitarExpanderClienteAdministradoConcorrente();
			}

			if(objListCliente[0].PercentualTotal.HasValue && objListCliente[0].PercentualTotal.Value != 0){
				//Cobrança pelo custo total
				Ordem.PercentualReducaoAcrescimo = objListCliente[0].PercentualTotal;
			}else{
				Ordem.PercentualReducaoAcrescimo = objListCliente[0].PercentualReducaoAcrescimo;
			}

			//recupera broker
			objConsultarCliente.Apelido = string.Empty;
			objConsultarCliente.Codigo = objListCliente[0].ClienteBroker;
			ModelCollection<Model.Cliente> objListClienteBroker = objCommCliente.ConsultarCliente(objConsultarCliente);
			if(objListClienteBroker != null && objListClienteBroker.Count > 0){
				Ordem.ApelidoBroker = objListClienteBroker[0].Apelido;
			}

			Cliente = objListCliente[0];

			//Regra 8
			bool flagCondicao = false;
			//Verifica se TipoMecado já foi selecionado
			if(Ordem.TipoMercado != null){
				//COMENTADO ERRO NO SERVIÇO DE PARAMETRO
				//if(objCommPar.RecuperarIndicadorTipoLiquidacaoCustodianteAutomatico().ToUpper() == "S"){
					if(Ordem.TipoMercado.Value != Sinacor.UI.Bovespa.Ordens.Model.Enum.TipoMercado.OpcaoCompra || Ordem.TipoMercado.Value != Sinacor.UI.Bovespa.Ordens.Model.Enum.TipoMercado.OpcaoVenda || Ordem.TipoMercado.Value != Sinacor.UI.Bovespa.Ordens.Model.Enum.TipoMercado.Termo || Ordem.TipoMercado.Value != Sinacor.UI.Bovespa.Ordens.Model.Enum.TipoMercado.Futuro){
						objConsultarClientePorCodigo.CodigoCliente = Convert.ToInt32(objListCliente[0].Codigo.Value);

						if(objCommCliente.ConsultarAgenteCustodia(objConsultarClientePorCodigo) != null || objCommCliente.ConsultarUsuarioInstitucional(objConsultarClientePorCodigo) != null){
							flagCondicao = true;
							Ordem.IndicadorLiquidacao = "C";
						}
					}
				//}
			}
			if(!flagCondicao){
				Ordem.IndicadorLiquidacao = string.Empty;
			}

			//Regra 9
			objConsultarClientePorCodigo.CodigoCliente = Convert.ToInt32(objListCliente[0].Codigo.Value);
			if(objCommCliente.ValidarClienteBroker(objConsultarClientePorCodigo)){
				View.InformarTipoOrdemDiscricionaria();
			}

			//Regra 10
			Cliente.NomeCompleto = Cliente.Nome + " " + Cliente.ComplementoNome;

			//Regra 11
			Model.Parameter.ConsultarEmissorOrdem objConsultarEmissorOrdem = new Sinacor.UI.Bovespa.Ordens.Model.Parameter.ConsultarEmissorOrdem();
			objConsultarEmissorOrdem.Apelido = objListCliente[0].Apelido;
			objConsultarEmissorOrdem.CodigoCliente = objListCliente[0].Codigo;
			ListEmissorOrdem = objCommCliente.ConsultarEmissorOrdem(objConsultarEmissorOrdem);
			View.ApresentarClienteEmissorOrdem();

			//Regra 12
			if(objListCliente[0].isClienteQualificado){
				Titulo = new Sinacor.UI.Bovespa.Ordens.Model.Titulo();
				Titulo.Codigo = Ordem.Titulo;
				Titulo.DataPregao = DataPregao;
				ValidarAtivo();
			}

			//Apresenta Todas as alterações do expander cliente
			View.ApresentarExpanderCliente();

			return true;
        }

        /// <summary>
        /// 1. Verificar se o Ativo informado existe no Cadastro de Ativos e:
		/// 1.1. se exisitir, atribuir a combinação entre o Nome da Empresa, a Especificação do Ativo e o Preço de Exercício formatado, a CamposAtivo::Descrição;
		/// 1.1.1. marcar o ExpanderAtivo::RadioBoxAtivo::Mercado conforme o Mercado cadastrado para o Ativo;
		/// 1.1.2. Atribuir o Mercado cadastrado para o Ativo à célula GridManutençãoOrdens::Mercado;
		/// 1.1.2.1. Se o Ativo informado for Termo e NÃO for Termo por Pontos, executar o evento habilita() do Expander::Ativo::CamposAtivo, passando como parâmetro <<VencimentoTermo>>;
		/// 1.1.2.2. Caso contrário, executar o evento desabilita() do Expander::Ativo::CamposAtivo, passando como parâmetros <<VencimentoTermo>> e <<limpar>>;
		/// 1.1.3. Quando o Ativo for POP (o código ISIN para o código digitado deve conter PP),
		/// 1.1.3.1. Se Expander::Cliente::CheckBoxCliente::AdministradoConcorrente estiver marcado, enviar a seguinte mensagem ao usuário:
		/// "Cliente Administrado Concorrente Não pode negociar POP.";
		/// 1.1.3.2. Atribuir <<277>> ao Expander::Ativo::CamposAtivo::Carteira;
		/// 1.1.4. Executar o evento carregar_controle() do Expander::Ativo::CamposAtivo::Carteira;
		/// 1.1.5. Executar o evento célula_atualizar() do GridManutençãoOrdens::Ordens, passando como parâmetros <<Ativo>> para célula e <<Ativo informado>> como valor;
		/// 1.2. se não existir, enviar a seguinte mensagem ao usuário:
		/// "Ativo não cadastrado."
        /// </summary>
        /// <param name="pCodigoAtivo"></param>
        public bool ValidarAtivo(){
			if(String.IsNullOrEmpty(Titulo.Codigo)){
				View.InformarAtivoNaoEncontrado();
				return false;
			}

			if(Titulo.DataPregao == null || Titulo.DataPregao.Value == DateTime.MinValue){
				View.InformarDataPregaoObrigatoria();
				return false;
			}

			Communication.Titulo objCommTitulo = new Sinacor.UI.Bovespa.Ordens.Communication.Titulo(this.Session);
			Titulo = objCommTitulo.ConsultarTituloCodigo(Titulo);
			if(Titulo == null){
				View.InformarAtivoNaoEncontrado();
				return false;
			}

			//1.1
			Titulo.NomeEmpresaEspecificacaoPreco = Titulo.Empresa + " " + Titulo.Especificacao + " " + Titulo.PrecoExercido.ToString();

			//1.1.1
			View.InformarMercado();

			//1.1.2
			//Pendente

			//1.1.2.1
			//1.1.2.2
			if(Titulo.Mercado.Value == Sinacor.UI.Bovespa.Ordens.Model.Enum.TipoMercado.Termo){
				//para verificar se o Termo não é por pontos, a parte numerica do codigo do negocio deve ser menor que 50
				string sNegocio = Titulo.Codigo;
				sNegocio.Remove(sNegocio.Length-1);
				try{
					int iPontos = Convert.ToInt32(sNegocio.Substring(4, sNegocio.Length-4));
					if(iPontos < 50){
						View.HabilitarExpanderAtivoVencimentoTermo();
					}else{
						View.LimparExpanderAtivoVencimentoTermo();
						View.DesabilitarExpanderAtivoVencimentoTermo();
					}
				}catch(Exception ex){
					View.HabilitarExpanderAtivoVencimentoTermo();
				}
			}else{
				View.LimparExpanderAtivoVencimentoTermo();
				View.DesabilitarExpanderAtivoVencimentoTermo();
			}

			//1.1.3
			//se houver PP no codigo isin então o papel é estratégia POP
			if(Titulo.Isin.ToUpper().IndexOf("PP") >= 0 && Cliente != null){
				//1.1.3.1
				if(Cliente.IsAdministradoCOncorrente){
					View.InformarClienteAdministradoConcorrenteNaoNegociarPOP();
					return false;
				}

				//1.1.3.2
				Ordem.CodigoCarteira = 277;
			}

			//1.1.4
			CarregarCarteira();

			return true;
        }

		/// <summary>
		/// 1. Se o parâmetro recebido NÃO for Nulo ou vazio,
		/// 1.1. Atribuir <<parâmetro>> ao controle;
		/// 2. Se o parâmetro recebido for Nulo ou vazio e o controle estiver vazio,
		/// 2.1. Se os controles Expander::Ordem::CamposOrdem::NaturezaOperação, Expander::Ativo::CamposAtivo::Bolsa e Expander::Ativo::RadioBoxAtivo::Mercado NÃO forem Nulos ou vazios,
		/// 2.1.1. Atribuir ao controle a Carteira de menor prioridade no Cadastro de Carteira para Bolsa, Mercado e Natureza da Operação informados nos respectivos controles;
		/// 3. Executar o evento carregar_controle() do Expander::Cliente::CamposCliente::Carteira, passando como parâmetro o conteúdo do controle;
		/// 4. Executar o evento célula_atualizar() do GridManutençãoOrdens::Ordens, passando como parâmetros <<Carteira>> para célula e <<Carteira informada>> como valor;
		/// </summary>
		public void CarregarCarteira(){
			if(Ordem.CodigoCarteira == null){
				//2.1
				//2.1.1
				if(Ordem.TipoMercado != null && Ordem.Bolsa != string.Empty){
					Model.Parameter.ConsultarMenorCarteiraRequest objConsultarMenorCarteira = new Sinacor.UI.Bovespa.Ordens.Model.Parameter.ConsultarMenorCarteiraRequest();
					objConsultarMenorCarteira.CodigoBolsa = Ordem.Bolsa;
					objConsultarMenorCarteira.CodigoMercado = (Model.Enum.TipoMercado?) Ordem.TipoMercado;
					objConsultarMenorCarteira.NaturezaOperacao = (Model.Enum.TipoNaturezaOperacao?)Ordem.NaturezaOperacao;
					Ordem.CodigoCarteira = new Communication.Carteira(this.Session).ConsultarMenorCarteira(objConsultarMenorCarteira).CodigoCarteira;
				}
			}
		}

		/// <summary>
		/// 1. Se ExpanderOrdem::CheckBoxTipoOrdem::Financiamento estiver marcado e GridManutençãoOrdens::Subsequência for 0 (zero) ou Nulo, ExpanderQuantidade::CamposQuantidade::Quantidade deve ser 0 (zero) e enviar a seguinte mensagem ao usuário:
		/// "Não deve haver Quantidade para Ordem de Financiamento.";
		/// 2. Caso contrário, ExpanderQuantidade::CamposQuantidade::Quantidade deve ser MAIOR QUE 0 (zero); enviar a seguinte mensagem ao usuário:
		/// "A digitação da Quantidade é obrigatória.";
		/// 3. Se quantidade digitada NÃO FOR um múltiplo do valor especificado como lote mínimo de negociação, para o Ativo e Mercado informados na Ordem,
		///		enviar a seguinte mensagem ao usuário:
		///		"Quantidade incompatível com o lote mínimo de negociação."
		/// 4. A soma das quantidades informadas nos campos QuantidadeAnexoIV e QuantidadeAnexoV NÃO pode ser MAIOR QUE a quantidade informada no campo Quantidade;
		/// 5. Executar o evento célula_atualizar do GridManutençãoOrdens::Ordens, passando como parâmetros <<Quantidade>> para célula e o campo <<Quantidade>> para valor;
		/// </summary>
		/// <returns></returns>
		public bool ValidarQuantidade(){
			//1 /*Atenção a Regra de verificação se a subsequencia da ordem não foi feita, pois a consulta desse grid só retorna os zeros e nulos*/
			bool flagFinanciamento = false;
			for(int i=0; i<Ordem.TipoOrdem.Count; i++){
				if(Ordem.TipoOrdem[i].Value == Sinacor.UI.Bovespa.Ordens.Model.Enum.TipoOrdem.Financiamento){
					flagFinanciamento = true;
					break;
				}
			}
			if(flagFinanciamento && Ordem.Quantidade.HasValue){
				if(Ordem.Quantidade.Value > 0){
					View.InformarNaoDeveHaverQuantidadeParaFinanciamento();
					return false;
				}
			}

			//2
			if(!Ordem.Quantidade.HasValue || Ordem.Quantidade.Value < 1){
				View.InformarQuantidadeObrigatoria();
				return false;
			}

			//3
			if(Ordem.Titulo != string.Empty){
				Communication.Titulo objCommTitulo = new Sinacor.UI.Bovespa.Ordens.Communication.Titulo(this.Session);
				Model.Parameter.ConsultarLoteMinimoNegociacaoRequest objConsultarLoteMinimoNegociacao = new Sinacor.UI.Bovespa.Ordens.Model.Parameter.ConsultarLoteMinimoNegociacaoRequest();
				objConsultarLoteMinimoNegociacao._DataPregao = Calendario.DataPregao;
				objConsultarLoteMinimoNegociacao._Titulo = Ordem.Titulo;
				if(Ordem.Quantidade % objCommTitulo.ConsultarLoteMinimoNegociacao(objConsultarLoteMinimoNegociacao) != 0){
					View.InformarQuantidadeNaoMultiploLoteMinimo();
					return false;
				}
			}
			return true;
		}

		/// <summary>
		/// 1. Validar para Tipos de Ordem:
		/// 1.1. Para Expander::Ordem::CheckBoxTipoOrdem::Limitada ou Expander::Ordem::CheckBoxTipoOrdem::OnStop marcados, o
		///		Preço em Expander::Quantidade::CamposQuantidade::Preço é obrigatório e deve ser MAIOR QUE 0 (zero). Se o valor digitado for MENOR ou IGUAL a 0 (zero),
		///		enviar a seguinte mensagem ao usuário:
		///		"Preço informado deve ser maior que 0 (zero).";
		/// 1.2. Para os demais Tipos de Ordem, executar evento desabilita() de Expander::Quantidade::CamposQuantidade::Preço;
		/// 2. Executar o evento célula_atualizar do GridManutençãoOrdens::Ordens, passando como parâmetros <<Preço>> para célula e o campo <<Preço>> para valor;
		/// </summary>
		/// <returns></returns>
		public bool ValidarPreco(){
			for(int i=0; i<Ordem.TipoOrdem.Count; i++){
				if(Ordem.TipoOrdem[i].Value == Sinacor.UI.Bovespa.Ordens.Model.Enum.TipoOrdem.Limitada || Ordem.TipoOrdem[i].Value == Sinacor.UI.Bovespa.Ordens.Model.Enum.TipoOrdem.OnStop){
					if(!Ordem.Preco.HasValue || Ordem.Preco.Value <= 0){
						View.InformarPrecoInvalido();
						return false;
					}
				}
			}
			return true;
		}

		/// <summary>
		/// 1. Para clientes com cobrança de corretagem pelo custo total, o valor digitado deve ser maior ou igual a 0 (zero). 
		/// Para os demais clientes, este valor deve ser maior ou igual a -100 (menos 100);
		/// 1.1. Se o Percentual informado for inválido, enviar a seguinte mensagem ao usuário:
		/// "Percentual incompatível com o Tipo de Cobrança de Corretagem do Cliente.";
		/// 2. Executar o evento célula_atualizar() do GridManutençãoOrdens::Ordens, passando como parâmetros <<PercentualAcréscimoRedução>>
		///		para célula e <<Conteúdo do controle>> como valor;
		/// </summary>
		/// <returns></returns>
		public bool ValidarPercentualAcrescimoReducao(){
			if(Cliente == null){
				return false;
			}

			if(Cliente.Apelido == string.Empty){
				return false;
			}

			if(!Cliente.PercentualTotal.HasValue || Cliente.PercentualTotal.Value <= 0){
				if(!Ordem.PercentualReducaoAcrescimo.HasValue || Ordem.PercentualReducaoAcrescimo.Value < 0){
					View.InformarPercentualIncompativelTipoCobrancaCorretagemCliente();
					return false;
				}
			}else{
				//demais clientes
				if(!Ordem.PercentualReducaoAcrescimo.HasValue || Ordem.PercentualReducaoAcrescimo.Value < -100){
					View.InformarPercentualIncompativelTipoCobrancaCorretagemCliente();
					return false;
				}
			}

			return true;
		}

		/// <summary>
		/// 1. Se estiver parametrizada a verificação de bloqueio de cliente, verificar o bloqueio para o Cliente, Mercado, Natureza de Operação, Ativo e
		///		Pregão informados. Se a Data de Validade em ValidadeOrdem de CamposOrdem do Expander::Ordens for MENOR QUE a Data do Sistema, utilizar
		///		a Data da Validade da Ordem e não a Data do Pregão, para fazer esta verificação;
		/// 2. Executar os eventos valida() de todos os controles:
		/// 2.1.Se todos foram validados,
		/// 2.1.1. Criar novo número para a Ordem, baseado na sequência do último número cadastrado;
		/// 2.1.2. Salvar o conteúdo de todos os controles na nova Ordem criada;
		/// 2.1.3. Atualizar o controle de numeração de Ordens;
		/// 2.1.4. Atualizar o GridManutençãoOrdens::Ordens;
		/// 2.1.5. Executar evento habilita() de BotõesManutençãoOrdens::PréBoleto;
		/// 3. Se o sistema está parametrizado para efetuar verificação de saldo negociável, efetuar a verificação, desde que Natureza da Operação
		///		informada seja <<V>>, e enviar a mensagem recebida da rotina de verificação de saldo negociável ao usuário;
		/// 4. Executar evento calcula_ValorOrdem() em Expander::Quantidade::CamposQuantidade::ValorOrdem, para a nova Ordem;
		/// </summary>
		/// <returns></returns>
		public bool SalvarNovaOrdem(){
			Communication.Parametro objCommParametro = new Sinacor.UI.Bovespa.Ordens.Communication.Parametro(this.Session);
			if(objCommParametro.RecuperarIndicadorBloqueio().ToUpper() == "S"){
				Communication.Cliente objCommCliente = new Sinacor.UI.Bovespa.Ordens.Communication.Cliente(this.Session);
				Model.Parameter.VerificarBloqueioCliente objVerificarBloqueioCliente = new Sinacor.UI.Bovespa.Ordens.Model.Parameter.VerificarBloqueioCliente();
				objVerificarBloqueioCliente.CodigoCliente = Cliente.Codigo;
				objVerificarBloqueioCliente.CodNegocio = Ordem.Titulo;
				if(Ordem.DataValidade.Value.Date < DateTime.Now.Date){
					objVerificarBloqueioCliente.DataPregao = Ordem.DataValidade;
				}else{
					objVerificarBloqueioCliente.DataPregao = Calendario.DataPregao;
				}
				objVerificarBloqueioCliente.Mercado = (Model.Enum.TipoMercado?) Ordem.TipoMercado;
				objVerificarBloqueioCliente.NaturezaOperacao = (Model.Enum.TipoNaturezaOperacao)Ordem.NaturezaOperacao;

				Model.VerificarBloqueioCliente objModelVerificarBloqueioCliente = objCommCliente.VerificarBloqueioCliente(objVerificarBloqueioCliente);
				if(objModelVerificarBloqueioCliente.isBloqueado){
					View.InformarMensagem(objModelVerificarBloqueioCliente.DescricaoBloqueio);
					return false;
				}
			}

			bool flagAtivo = false, flagCliente = false, flagPercentualAcrescimoReducao = false, flagPreco = false, flagQuantidade = false, flagSituacaoOrdem = false,
					flagTitulo = false, flagValorFinanciamento = false;
			flagAtivo = ValidarAtivo();
			flagCliente = ValidarCliente(false);
			flagPercentualAcrescimoReducao = ValidarPercentualAcrescimoReducao();
			flagPreco = ValidarPreco();
			flagQuantidade = ValidarQuantidade();
			flagSituacaoOrdem = ValidarSituacaoOrdem();
			flagTitulo = ValidarTitulo(Titulo);
			flagValorFinanciamento = ValidarValorFinanciamento();

			if(!flagAtivo || !flagCliente || !flagPercentualAcrescimoReducao || !flagPreco || !flagQuantidade || !flagSituacaoOrdem || !flagTitulo || !flagValorFinanciamento){
				return false;
			}

			
			return true;
		}

		/// <summary>
		/// 1. Se a Situação da Ordem informada NÃO pertencer ao domínio, enviar a seguinte mensagem ao usuário:
		/// "Código para Situação inválido."
		/// 2. Executar o evento célula_atualizar do GridManutençãoOrdens::Ordens, passando como parâmetros <<SituaçãoOrdem>> para célula
		///		e <<Expander::Ordem::CamposOrdem::SituaçãoOrdem>> para valor;
		/// </summary>
		/// <returns></returns>
		public bool ValidarSituacaoOrdem(){
			switch(Ordem.Situacao.ToUpper()){
				case "D":
				case "H":
				case "S":
				case "E":
				case "A":
					return true;
					break;
				default:
					View.InformarCodigoSituacaoInvalido();
					return false;
					break;
			}
		}

		/// <summary>
		/// 1. Se Expander::Ordem::CheckBoxTipoOrdem::Financiamento estiver marcado, 
		/// 1.1. Expander::Ordem::CamposOrdem::ValorFinanciamento obrigatoriamente deve ser MAIOR QUE 0 (zero). 
		/// 1.2. Se for 0 (zero) ou NULO, enviar a seguinte mensagem ao usuário:
		/// "Para Ordem do Tipo Financiamento, o Valor do Financiamento deve ser maior que 0 (zero)."
		/// 2. Executar o evento célula_atualizar() de GridManutençãoOrdens::Ordens, passando como
		///		parâmetros <<GridManutençãoOrdens::Ordens::ValorFinanciamento>> para célula e <<Expander::Ordem::CamposOrdem::ValorFinanciamento>> para valor;
		/// </summary>
		/// <returns></returns>
		public bool ValidarValorFinanciamento(){
			bool flagFinanciamento = false;
			for(int i=0; i<Ordem.TipoOrdem.Count; i++){
				if(Ordem.TipoOrdem[i].Value == Sinacor.UI.Bovespa.Ordens.Model.Enum.TipoOrdem.Financiamento){
					flagFinanciamento = true;
					break;
				}
			}

			if(!flagFinanciamento){
				return true;
			}

			if(!Ordem.ValorFinanciado.HasValue || Ordem.ValorFinanciado.Value <= 0){
				View.InformarValorFinancimanetoObrigatorio();
				return false;
			}

			return true;
		}
        #endregion Metodo
    }
}